{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-title"
    ]
   },
   "source": [
    "# Implementing a Neural Network\n",
    "In this exercise we will develop a neural network with fully-connected layers to perform classification, and test it out on the CIFAR-10 dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [],
   "source": [
    "# A bit of setup\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from cs231n.classifiers.neural_net import TwoLayerNet\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading external modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "def rel_error(x, y):\n",
    "    \"\"\" returns relative error \"\"\"\n",
    "    return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "source": [
    "We will use the class `TwoLayerNet` in the file `cs231n/classifiers/neural_net.py` to represent instances of our network. The network parameters are stored in the instance variable `self.params` where keys are string parameter names and values are numpy arrays. Below, we initialize toy data and a toy model that we will use to develop your implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [],
   "source": [
    "# Create a small net and some toy data to check your implementations.\n",
    "# Note that we set the random seed for repeatable experiments.\n",
    "\n",
    "input_size = 4\n",
    "hidden_size = 10\n",
    "num_classes = 3\n",
    "num_inputs = 5\n",
    "\n",
    "def init_toy_model():\n",
    "    np.random.seed(0)\n",
    "    return TwoLayerNet(input_size, hidden_size, num_classes, std=1e-1)\n",
    "\n",
    "def init_toy_data():\n",
    "    np.random.seed(1)\n",
    "    X = 10 * np.random.randn(num_inputs, input_size)\n",
    "    y = np.array([0, 1, 2, 2, 1])\n",
    "    return X, y\n",
    "\n",
    "net = init_toy_model()\n",
    "X, y = init_toy_data()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Forward pass: compute scores\n",
    "Open the file `cs231n/classifiers/neural_net.py` and look at the method `TwoLayerNet.loss`. This function is very similar to the loss functions you have written for the SVM and Softmax exercises: It takes the data and weights and computes the class scores, the loss, and the gradients on the parameters. \n",
    "\n",
    "Implement the first part of the forward pass which uses the weights and biases to compute the scores for all inputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your scores:\n",
      "[[-0.81233741 -1.27654624 -0.70335995]\n",
      " [-0.17129677 -1.18803311 -0.47310444]\n",
      " [-0.51590475 -1.01354314 -0.8504215 ]\n",
      " [-0.15419291 -0.48629638 -0.52901952]\n",
      " [-0.00618733 -0.12435261 -0.15226949]]\n",
      "\n",
      "correct scores:\n",
      "[[-0.81233741 -1.27654624 -0.70335995]\n",
      " [-0.17129677 -1.18803311 -0.47310444]\n",
      " [-0.51590475 -1.01354314 -0.8504215 ]\n",
      " [-0.15419291 -0.48629638 -0.52901952]\n",
      " [-0.00618733 -0.12435261 -0.15226949]]\n",
      "\n",
      "Difference between your scores and correct scores:\n",
      "3.6802720496109664e-08\n"
     ]
    }
   ],
   "source": [
    "scores = net.loss(X)\n",
    "print('Your scores:')\n",
    "print(scores)\n",
    "print()\n",
    "print('correct scores:')\n",
    "correct_scores = np.asarray([\n",
    "  [-0.81233741, -1.27654624, -0.70335995],\n",
    "  [-0.17129677, -1.18803311, -0.47310444],\n",
    "  [-0.51590475, -1.01354314, -0.8504215 ],\n",
    "  [-0.15419291, -0.48629638, -0.52901952],\n",
    "  [-0.00618733, -0.12435261, -0.15226949]])\n",
    "print(correct_scores)\n",
    "print()\n",
    "\n",
    "# The difference should be very small. We get < 1e-7\n",
    "print('Difference between your scores and correct scores:')\n",
    "print(np.sum(np.abs(scores - correct_scores)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Forward pass: compute loss\n",
    "In the same function, implement the second part that computes the data and regularization loss."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Difference between your loss and correct loss:\n",
      "1.794120407794253e-13\n"
     ]
    }
   ],
   "source": [
    "loss, _ = net.loss(X, y, reg=0.05)\n",
    "correct_loss = 1.30378789133\n",
    "\n",
    "# should be very small, we get < 1e-12\n",
    "print('Difference between your loss and correct loss:')\n",
    "print(np.sum(np.abs(loss - correct_loss)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Backward pass\n",
    "Implement the rest of the function. This will compute the gradient of the loss with respect to the variables `W1`, `b1`, `W2`, and `b2`. Now that you (hopefully!) have a correctly implemented forward pass, you can debug your backward pass using a numeric gradient check:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "W2 max relative error: 3.440708e-09\n",
      "b2 max relative error: 3.865028e-11\n",
      "W1 max relative error: 3.669858e-09\n",
      "b1 max relative error: 2.738422e-09\n"
     ]
    }
   ],
   "source": [
    "from cs231n.gradient_check import eval_numerical_gradient\n",
    "\n",
    "# Use numeric gradient checking to check your implementation of the backward pass.\n",
    "# If your implementation is correct, the difference between the numeric and\n",
    "# analytic gradients should be less than 1e-8 for each of W1, W2, b1, and b2.\n",
    "\n",
    "loss, grads = net.loss(X, y, reg=0.05)\n",
    "\n",
    "# these should all be less than 1e-8 or so\n",
    "for param_name in grads:\n",
    "    f = lambda W: net.loss(X, y, reg=0.05)[0]\n",
    "    param_grad_num = eval_numerical_gradient(f, net.params[param_name], verbose=False)\n",
    "    print('%s max relative error: %e' % (param_name, rel_error(param_grad_num, grads[param_name])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train the network\n",
    "To train the network we will use stochastic gradient descent (SGD), similar to the SVM and Softmax classifiers. Look at the function `TwoLayerNet.train` and fill in the missing sections to implement the training procedure. This should be very similar to the training procedure you used for the SVM and Softmax classifiers. You will also have to implement `TwoLayerNet.predict`, as the training process periodically performs prediction to keep track of accuracy over time while the network trains.\n",
    "\n",
    "Once you have implemented the method, run the code below to train a two-layer network on toy data. You should achieve a training loss less than 0.02."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "id": "final_training_loss"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Final training loss:  0.01563498761185671\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "net = init_toy_model()\n",
    "stats = net.train(X, y, X, y,\n",
    "            learning_rate=1e-1, reg=5e-6,\n",
    "            num_iters=100, verbose=False)\n",
    "\n",
    "print('Final training loss: ', stats['loss_history'][-1])\n",
    "\n",
    "# plot the loss history\n",
    "plt.plot(stats['loss_history'])\n",
    "plt.xlabel('iteration')\n",
    "plt.ylabel('training loss')\n",
    "plt.title('Training Loss history')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load the data\n",
    "Now that you have implemented a two-layer network that passes gradient checks and works on toy data, it's time to load up our favorite CIFAR-10 data so we can use it to train a classifier on a real dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train data shape:  (49000, 3072)\n",
      "Train labels shape:  (49000,)\n",
      "Validation data shape:  (1000, 3072)\n",
      "Validation labels shape:  (1000,)\n",
      "Test data shape:  (1000, 3072)\n",
      "Test labels shape:  (1000,)\n"
     ]
    }
   ],
   "source": [
    "from cs231n.data_utils import load_CIFAR10\n",
    "\n",
    "def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000):\n",
    "    \"\"\"\n",
    "    Load the CIFAR-10 dataset from disk and perform preprocessing to prepare\n",
    "    it for the two-layer neural net classifier. These are the same steps as\n",
    "    we used for the SVM, but condensed to a single function.  \n",
    "    \"\"\"\n",
    "    # Load the raw CIFAR-10 data\n",
    "    cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n",
    "    \n",
    "    # Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n",
    "    try:\n",
    "       del X_train, y_train\n",
    "       del X_test, y_test\n",
    "       print('Clear previously loaded data.')\n",
    "    except:\n",
    "       pass\n",
    "\n",
    "    X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n",
    "        \n",
    "    # Subsample the data\n",
    "    mask = list(range(num_training, num_training + num_validation))\n",
    "    X_val = X_train[mask]\n",
    "    y_val = y_train[mask]\n",
    "    mask = list(range(num_training))\n",
    "    X_train = X_train[mask]\n",
    "    y_train = y_train[mask]\n",
    "    mask = list(range(num_test))\n",
    "    X_test = X_test[mask]\n",
    "    y_test = y_test[mask]\n",
    "\n",
    "    # Normalize the data: subtract the mean image\n",
    "    mean_image = np.mean(X_train, axis=0)\n",
    "    X_train -= mean_image\n",
    "    X_val -= mean_image\n",
    "    X_test -= mean_image\n",
    "\n",
    "    # Reshape data to rows\n",
    "    X_train = X_train.reshape(num_training, -1)\n",
    "    X_val = X_val.reshape(num_validation, -1)\n",
    "    X_test = X_test.reshape(num_test, -1)\n",
    "\n",
    "    return X_train, y_train, X_val, y_val, X_test, y_test\n",
    "\n",
    "\n",
    "# Invoke the above function to get our data.\n",
    "X_train, y_train, X_val, y_val, X_test, y_test = get_CIFAR10_data()\n",
    "print('Train data shape: ', X_train.shape)\n",
    "print('Train labels shape: ', y_train.shape)\n",
    "print('Validation data shape: ', X_val.shape)\n",
    "print('Validation labels shape: ', y_val.shape)\n",
    "print('Test data shape: ', X_test.shape)\n",
    "print('Test labels shape: ', y_test.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train a network\n",
    "To train our network we will use SGD. In addition, we will adjust the learning rate with an exponential learning rate schedule as optimization proceeds; after each epoch, we will reduce the learning rate by multiplying it by a decay rate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "tags": [
     "code"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 0 / 1200: loss 2.302966\n",
      "iteration 100 / 1200: loss 2.302569\n",
      "iteration 200 / 1200: loss 2.298687\n",
      "iteration 300 / 1200: loss 2.268545\n",
      "iteration 400 / 1200: loss 2.156338\n",
      "iteration 500 / 1200: loss 2.166976\n",
      "iteration 600 / 1200: loss 2.017247\n",
      "iteration 700 / 1200: loss 2.076479\n",
      "iteration 800 / 1200: loss 1.988270\n",
      "iteration 900 / 1200: loss 1.934011\n",
      "iteration 1000 / 1200: loss 1.941990\n",
      "iteration 1100 / 1200: loss 1.910048\n",
      "Validation accuracy:  0.259\n"
     ]
    }
   ],
   "source": [
    "input_size = 32 * 32 * 3\n",
    "hidden_size = 50\n",
    "num_classes = 10\n",
    "net = TwoLayerNet(input_size, hidden_size, num_classes)\n",
    "\n",
    "# Train the network\n",
    "stats = net.train(X_train, y_train, X_val, y_val,\n",
    "            num_iters=1200, batch_size=200,\n",
    "            learning_rate=1e-4, learning_rate_decay=0.95,\n",
    "            reg=0.25, verbose=True)\n",
    "\n",
    "# Predict on the validation set\n",
    "val_acc = (net.predict(X_val) == y_val).mean()\n",
    "print('Validation accuracy: ', val_acc)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Debug the training\n",
    "With the default parameters we provided above, you should get a validation accuracy of about 0.29 on the validation set. This isn't very good.\n",
    "\n",
    "One strategy for getting insight into what's wrong is to plot the loss function and the accuracies on the training and validation sets during optimization.\n",
    "\n",
    "Another strategy is to visualize the weights that were learned in the first layer of the network. In most neural networks trained on visual data, the first layer weights typically show some visible structure when visualized."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the loss function and train / validation accuracies\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.plot(stats['loss_history'])\n",
    "plt.title('Loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Loss')\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.plot(stats['train_acc_history'], label='train')\n",
    "plt.plot(stats['val_acc_history'], label='val')\n",
    "plt.title('Classification accuracy history')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Classification accuracy')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from cs231n.vis_utils import visualize_grid\n",
    "\n",
    "# Visualize the weights of the network\n",
    "\n",
    "def show_net_weights(net):\n",
    "    W1 = net.params['W1']\n",
    "    W1 = W1.reshape(32, 32, 3, -1).transpose(3, 0, 1, 2)\n",
    "    plt.imshow(visualize_grid(W1, padding=3).astype('uint8'))\n",
    "    plt.gca().axis('off')\n",
    "    plt.show()\n",
    "\n",
    "show_net_weights(net)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tune your hyperparameters\n",
    "\n",
    "**What's wrong?**. Looking at the visualizations above, we see that the loss is decreasing more or less linearly, which seems to suggest that the learning rate may be too low. Moreover, there is no gap between the training and validation accuracy, suggesting that the model we used has low capacity, and that we should increase its size. On the other hand, with a very large model we would expect to see more overfitting, which would manifest itself as a very large gap between the training and validation accuracy.\n",
    "\n",
    "**Tuning**. Tuning the hyperparameters and developing intuition for how they affect the final performance is a large part of using Neural Networks, so we want you to get a lot of practice. Below, you should experiment with different values of the various hyperparameters, including hidden layer size, learning rate, numer of training epochs, and regularization strength. You might also consider tuning the learning rate decay, but you should be able to get good performance using the default value.\n",
    "\n",
    "**Approximate results**. You should be aim to achieve a classification accuracy of greater than 48% on the validation set. Our best network gets over 52% on the validation set.\n",
    "\n",
    "**Experiment**: You goal in this exercise is to get as good of a result on CIFAR-10 as you can (52% could serve as a reference), with a fully-connected Neural Network. Feel free implement your own techniques (e.g. PCA to reduce dimensionality, or adding dropout, or adding features to the solver, etc.)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "**Explain your hyperparameter tuning process below.**\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "tags": [
     "code"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.00556897 0.00560345 0.00563793 0.00567241 0.0057069  0.00574138\n",
      " 0.00577586 0.00581034 0.00584483 0.00587931 0.00591379 0.00594828\n",
      " 0.00598276 0.00601724 0.00605172 0.00608621 0.00612069 0.00615517\n",
      " 0.00618966 0.00622414 0.00625862 0.0062931  0.00632759 0.00636207\n",
      " 0.00639655 0.00643103 0.00646552 0.0065     0.00653448 0.00656897]\n",
      "lr: 0.008258620689655173 reg: 0.005568965517241379\n",
      "iteration 0 / 1500: loss 2.302578   val_acc=0.118000\n",
      "iteration 0 / 1500: loss 2.302578   val_acc=0.118000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008258620689655173 reg: 0.005603448275862068\n",
      "iteration 0 / 1500: loss 2.302586   val_acc=0.083000\n",
      "iteration 0 / 1500: loss 2.302586   val_acc=0.083000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008258620689655173 reg: 0.005637931034482758\n",
      "iteration 0 / 1500: loss 2.302595   val_acc=0.062000\n",
      "iteration 0 / 1500: loss 2.302595   val_acc=0.062000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008258620689655173 reg: 0.005672413793103448\n",
      "iteration 0 / 1500: loss 2.302614   val_acc=0.161000\n",
      "iteration 0 / 1500: loss 2.302614   val_acc=0.161000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008258620689655173 reg: 0.005706896551724137\n",
      "iteration 0 / 1500: loss 2.302644   val_acc=0.101000\n",
      "iteration 0 / 1500: loss 2.302644   val_acc=0.101000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008258620689655173 reg: 0.005741379310344827\n",
      "iteration 0 / 1500: loss 2.302611   val_acc=0.116000\n",
      "iteration 0 / 1500: loss 2.302611   val_acc=0.116000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008258620689655173 reg: 0.005775862068965517\n",
      "iteration 0 / 1500: loss 2.302576   val_acc=0.079000\n",
      "iteration 0 / 1500: loss 2.302576   val_acc=0.079000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008258620689655173 reg: 0.0058103448275862064\n",
      "iteration 0 / 1500: loss 2.302606   val_acc=0.157000\n",
      "iteration 0 / 1500: loss 2.302606   val_acc=0.157000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008258620689655173 reg: 0.005844827586206896\n",
      "iteration 0 / 1500: loss 2.302594   val_acc=0.119000\n",
      "iteration 0 / 1500: loss 2.302594   val_acc=0.119000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008258620689655173 reg: 0.005879310344827585\n",
      "iteration 0 / 1500: loss 2.302596   val_acc=0.112000\n",
      "iteration 0 / 1500: loss 2.302596   val_acc=0.112000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008258620689655173 reg: 0.005913793103448276\n",
      "iteration 0 / 1500: loss 2.302530   val_acc=0.103000\n",
      "iteration 0 / 1500: loss 2.302530   val_acc=0.103000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008258620689655173 reg: 0.005948275862068965\n",
      "iteration 0 / 1500: loss 2.302614   val_acc=0.081000\n",
      "iteration 0 / 1500: loss 2.302614   val_acc=0.081000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008258620689655173 reg: 0.0059827586206896545\n",
      "iteration 0 / 1500: loss 2.302643   val_acc=0.109000\n",
      "iteration 0 / 1500: loss 2.302643   val_acc=0.109000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008258620689655173 reg: 0.006017241379310345\n",
      "iteration 0 / 1500: loss 2.302575   val_acc=0.085000\n",
      "iteration 0 / 1500: loss 2.302575   val_acc=0.085000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008258620689655173 reg: 0.006051724137931034\n",
      "iteration 0 / 1500: loss 2.302641   val_acc=0.105000\n",
      "iteration 0 / 1500: loss 2.302641   val_acc=0.105000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008258620689655173 reg: 0.006086206896551724\n",
      "iteration 0 / 1500: loss 2.302602   val_acc=0.100000\n",
      "iteration 0 / 1500: loss 2.302602   val_acc=0.100000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008258620689655173 reg: 0.006120689655172413\n",
      "iteration 0 / 1500: loss 2.302607   val_acc=0.107000\n",
      "iteration 0 / 1500: loss 2.302607   val_acc=0.107000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008258620689655173 reg: 0.0061551724137931035\n",
      "iteration 0 / 1500: loss 2.302599   val_acc=0.151000\n",
      "iteration 0 / 1500: loss 2.302599   val_acc=0.151000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008258620689655173 reg: 0.006189655172413793\n",
      "iteration 0 / 1500: loss 2.302586   val_acc=0.092000\n",
      "iteration 0 / 1500: loss 2.302586   val_acc=0.092000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008258620689655173 reg: 0.006224137931034482\n",
      "iteration 0 / 1500: loss 2.302592   val_acc=0.115000\n",
      "iteration 0 / 1500: loss 2.302592   val_acc=0.115000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008258620689655173 reg: 0.006258620689655173\n",
      "iteration 0 / 1500: loss 2.302589   val_acc=0.088000\n",
      "iteration 0 / 1500: loss 2.302589   val_acc=0.088000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008258620689655173 reg: 0.006293103448275862\n",
      "iteration 0 / 1500: loss 2.302596   val_acc=0.181000\n",
      "iteration 0 / 1500: loss 2.302596   val_acc=0.181000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008258620689655173 reg: 0.006327586206896552\n",
      "iteration 0 / 1500: loss 2.302580   val_acc=0.121000\n",
      "iteration 0 / 1500: loss 2.302580   val_acc=0.121000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008258620689655173 reg: 0.006362068965517241\n",
      "iteration 0 / 1500: loss 2.302558   val_acc=0.103000\n",
      "iteration 0 / 1500: loss 2.302558   val_acc=0.103000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008258620689655173 reg: 0.0063965517241379305\n",
      "iteration 0 / 1500: loss 2.302592   val_acc=0.064000\n",
      "iteration 0 / 1500: loss 2.302592   val_acc=0.064000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008258620689655173 reg: 0.006431034482758621\n",
      "iteration 0 / 1500: loss 2.302595   val_acc=0.109000\n",
      "iteration 0 / 1500: loss 2.302595   val_acc=0.109000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008258620689655173 reg: 0.00646551724137931\n",
      "iteration 0 / 1500: loss 2.302596   val_acc=0.076000\n",
      "iteration 0 / 1500: loss 2.302596   val_acc=0.076000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008258620689655173 reg: 0.0065\n",
      "iteration 0 / 1500: loss 2.302600   val_acc=0.132000\n",
      "iteration 0 / 1500: loss 2.302600   val_acc=0.132000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008258620689655173 reg: 0.00653448275862069\n",
      "iteration 0 / 1500: loss 2.302614   val_acc=0.166000\n",
      "iteration 0 / 1500: loss 2.302614   val_acc=0.166000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008258620689655173 reg: 0.0065689655172413795\n",
      "iteration 0 / 1500: loss 2.302609   val_acc=0.146000\n",
      "iteration 0 / 1500: loss 2.302609   val_acc=0.146000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008369731800766283 reg: 0.005568965517241379\n",
      "iteration 0 / 1500: loss 2.302588   val_acc=0.079000\n",
      "iteration 0 / 1500: loss 2.302588   val_acc=0.079000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008369731800766283 reg: 0.005603448275862068\n",
      "iteration 0 / 1500: loss 2.302563   val_acc=0.108000\n",
      "iteration 0 / 1500: loss 2.302563   val_acc=0.108000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008369731800766283 reg: 0.005637931034482758\n",
      "iteration 0 / 1500: loss 2.302627   val_acc=0.118000\n",
      "iteration 0 / 1500: loss 2.302627   val_acc=0.118000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008369731800766283 reg: 0.005672413793103448\n",
      "iteration 0 / 1500: loss 2.302601   val_acc=0.095000\n",
      "iteration 0 / 1500: loss 2.302601   val_acc=0.095000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008369731800766283 reg: 0.005706896551724137\n",
      "iteration 0 / 1500: loss 2.302600   val_acc=0.100000\n",
      "iteration 0 / 1500: loss 2.302600   val_acc=0.100000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008369731800766283 reg: 0.005741379310344827\n",
      "iteration 0 / 1500: loss 2.302590   val_acc=0.114000\n",
      "iteration 0 / 1500: loss 2.302590   val_acc=0.114000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008369731800766283 reg: 0.005775862068965517\n",
      "iteration 0 / 1500: loss 2.302632   val_acc=0.118000\n",
      "iteration 0 / 1500: loss 2.302632   val_acc=0.118000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008369731800766283 reg: 0.0058103448275862064\n",
      "iteration 0 / 1500: loss 2.302609   val_acc=0.146000\n",
      "iteration 0 / 1500: loss 2.302609   val_acc=0.146000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008369731800766283 reg: 0.005844827586206896\n",
      "iteration 0 / 1500: loss 2.302613   val_acc=0.194000\n",
      "iteration 0 / 1500: loss 2.302613   val_acc=0.194000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008369731800766283 reg: 0.005879310344827585\n",
      "iteration 0 / 1500: loss 2.302612   val_acc=0.079000\n",
      "iteration 0 / 1500: loss 2.302612   val_acc=0.079000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008369731800766283 reg: 0.005913793103448276\n",
      "iteration 0 / 1500: loss 2.302582   val_acc=0.108000\n",
      "iteration 0 / 1500: loss 2.302582   val_acc=0.108000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008369731800766283 reg: 0.005948275862068965\n",
      "iteration 0 / 1500: loss 2.302572   val_acc=0.076000\n",
      "iteration 0 / 1500: loss 2.302572   val_acc=0.076000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008369731800766283 reg: 0.0059827586206896545\n",
      "iteration 0 / 1500: loss 2.302581   val_acc=0.067000\n",
      "iteration 0 / 1500: loss 2.302581   val_acc=0.067000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008369731800766283 reg: 0.006017241379310345\n",
      "iteration 0 / 1500: loss 2.302608   val_acc=0.097000\n",
      "iteration 0 / 1500: loss 2.302608   val_acc=0.097000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008369731800766283 reg: 0.006051724137931034\n",
      "iteration 0 / 1500: loss 2.302578   val_acc=0.119000\n",
      "iteration 0 / 1500: loss 2.302578   val_acc=0.119000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008369731800766283 reg: 0.006086206896551724\n",
      "iteration 0 / 1500: loss 2.302569   val_acc=0.171000\n",
      "iteration 0 / 1500: loss 2.302569   val_acc=0.171000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008369731800766283 reg: 0.006120689655172413\n",
      "iteration 0 / 1500: loss 2.302575   val_acc=0.111000\n",
      "iteration 0 / 1500: loss 2.302575   val_acc=0.111000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008369731800766283 reg: 0.0061551724137931035\n",
      "iteration 0 / 1500: loss 2.302599   val_acc=0.130000\n",
      "iteration 0 / 1500: loss 2.302599   val_acc=0.130000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008369731800766283 reg: 0.006189655172413793\n",
      "iteration 0 / 1500: loss 2.302602   val_acc=0.119000\n",
      "iteration 0 / 1500: loss 2.302602   val_acc=0.119000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008369731800766283 reg: 0.006224137931034482\n",
      "iteration 0 / 1500: loss 2.302597   val_acc=0.105000\n",
      "iteration 0 / 1500: loss 2.302597   val_acc=0.105000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008369731800766283 reg: 0.006258620689655173\n",
      "iteration 0 / 1500: loss 2.302557   val_acc=0.159000\n",
      "iteration 0 / 1500: loss 2.302557   val_acc=0.159000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008369731800766283 reg: 0.006293103448275862\n",
      "iteration 0 / 1500: loss 2.302592   val_acc=0.178000\n",
      "iteration 0 / 1500: loss 2.302592   val_acc=0.178000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008369731800766283 reg: 0.006327586206896552\n",
      "iteration 0 / 1500: loss 2.302579   val_acc=0.131000\n",
      "iteration 0 / 1500: loss 2.302579   val_acc=0.131000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008369731800766283 reg: 0.006362068965517241\n",
      "iteration 0 / 1500: loss 2.302600   val_acc=0.102000\n",
      "iteration 0 / 1500: loss 2.302600   val_acc=0.102000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008369731800766283 reg: 0.0063965517241379305\n",
      "iteration 0 / 1500: loss 2.302629   val_acc=0.158000\n",
      "iteration 0 / 1500: loss 2.302629   val_acc=0.158000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008369731800766283 reg: 0.006431034482758621\n",
      "iteration 0 / 1500: loss 2.302596   val_acc=0.082000\n",
      "iteration 0 / 1500: loss 2.302596   val_acc=0.082000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008369731800766283 reg: 0.00646551724137931\n",
      "iteration 0 / 1500: loss 2.302610   val_acc=0.112000\n",
      "iteration 0 / 1500: loss 2.302610   val_acc=0.112000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008369731800766283 reg: 0.0065\n",
      "iteration 0 / 1500: loss 2.302596   val_acc=0.141000\n",
      "iteration 0 / 1500: loss 2.302596   val_acc=0.141000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008369731800766283 reg: 0.00653448275862069\n",
      "iteration 0 / 1500: loss 2.302572   val_acc=0.117000\n",
      "iteration 0 / 1500: loss 2.302572   val_acc=0.117000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008369731800766283 reg: 0.0065689655172413795\n",
      "iteration 0 / 1500: loss 2.302586   val_acc=0.054000\n",
      "iteration 0 / 1500: loss 2.302586   val_acc=0.054000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008480842911877395 reg: 0.005568965517241379\n",
      "iteration 0 / 1500: loss 2.302592   val_acc=0.062000\n",
      "iteration 0 / 1500: loss 2.302592   val_acc=0.062000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008480842911877395 reg: 0.005603448275862068\n",
      "iteration 0 / 1500: loss 2.302607   val_acc=0.122000\n",
      "iteration 0 / 1500: loss 2.302607   val_acc=0.122000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008480842911877395 reg: 0.005637931034482758\n",
      "iteration 0 / 1500: loss 2.302599   val_acc=0.118000\n",
      "iteration 0 / 1500: loss 2.302599   val_acc=0.118000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008480842911877395 reg: 0.005672413793103448\n",
      "iteration 0 / 1500: loss 2.302572   val_acc=0.118000\n",
      "iteration 0 / 1500: loss 2.302572   val_acc=0.118000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008480842911877395 reg: 0.005706896551724137\n",
      "iteration 0 / 1500: loss 2.302605   val_acc=0.069000\n",
      "iteration 0 / 1500: loss 2.302605   val_acc=0.069000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008480842911877395 reg: 0.005741379310344827\n",
      "iteration 0 / 1500: loss 2.302592   val_acc=0.160000\n",
      "iteration 0 / 1500: loss 2.302592   val_acc=0.160000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008480842911877395 reg: 0.005775862068965517\n",
      "iteration 0 / 1500: loss 2.302592   val_acc=0.096000\n",
      "iteration 0 / 1500: loss 2.302592   val_acc=0.096000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008480842911877395 reg: 0.0058103448275862064\n",
      "iteration 0 / 1500: loss 2.302623   val_acc=0.091000\n",
      "iteration 0 / 1500: loss 2.302623   val_acc=0.091000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008480842911877395 reg: 0.005844827586206896\n",
      "iteration 0 / 1500: loss 2.302565   val_acc=0.161000\n",
      "iteration 0 / 1500: loss 2.302565   val_acc=0.161000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008480842911877395 reg: 0.005879310344827585\n",
      "iteration 0 / 1500: loss 2.302596   val_acc=0.147000\n",
      "iteration 0 / 1500: loss 2.302596   val_acc=0.147000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008480842911877395 reg: 0.005913793103448276\n",
      "iteration 0 / 1500: loss 2.302605   val_acc=0.121000\n",
      "iteration 0 / 1500: loss 2.302605   val_acc=0.121000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008480842911877395 reg: 0.005948275862068965\n",
      "iteration 0 / 1500: loss 2.302584   val_acc=0.093000\n",
      "iteration 0 / 1500: loss 2.302584   val_acc=0.093000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008480842911877395 reg: 0.0059827586206896545\n",
      "iteration 0 / 1500: loss 2.302583   val_acc=0.108000\n",
      "iteration 0 / 1500: loss 2.302583   val_acc=0.108000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008480842911877395 reg: 0.006017241379310345\n",
      "iteration 0 / 1500: loss 2.302594   val_acc=0.094000\n",
      "iteration 0 / 1500: loss 2.302594   val_acc=0.094000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008480842911877395 reg: 0.006051724137931034\n",
      "iteration 0 / 1500: loss 2.302587   val_acc=0.126000\n",
      "iteration 0 / 1500: loss 2.302587   val_acc=0.126000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008480842911877395 reg: 0.006086206896551724\n",
      "iteration 0 / 1500: loss 2.302602   val_acc=0.131000\n",
      "iteration 0 / 1500: loss 2.302602   val_acc=0.131000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008480842911877395 reg: 0.006120689655172413\n",
      "iteration 0 / 1500: loss 2.302604   val_acc=0.100000\n",
      "iteration 0 / 1500: loss 2.302604   val_acc=0.100000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008480842911877395 reg: 0.0061551724137931035\n",
      "iteration 0 / 1500: loss 2.302620   val_acc=0.081000\n",
      "iteration 0 / 1500: loss 2.302620   val_acc=0.081000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008480842911877395 reg: 0.006189655172413793\n",
      "iteration 0 / 1500: loss 2.302610   val_acc=0.147000\n",
      "iteration 0 / 1500: loss 2.302610   val_acc=0.147000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008480842911877395 reg: 0.006224137931034482\n",
      "iteration 0 / 1500: loss 2.302564   val_acc=0.137000\n",
      "iteration 0 / 1500: loss 2.302564   val_acc=0.137000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008480842911877395 reg: 0.006258620689655173\n",
      "iteration 0 / 1500: loss 2.302590   val_acc=0.163000\n",
      "iteration 0 / 1500: loss 2.302590   val_acc=0.163000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008480842911877395 reg: 0.006293103448275862\n",
      "iteration 0 / 1500: loss 2.302586   val_acc=0.092000\n",
      "iteration 0 / 1500: loss 2.302586   val_acc=0.092000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008480842911877395 reg: 0.006327586206896552\n",
      "iteration 0 / 1500: loss 2.302599   val_acc=0.123000\n",
      "iteration 0 / 1500: loss 2.302599   val_acc=0.123000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008480842911877395 reg: 0.006362068965517241\n",
      "iteration 0 / 1500: loss 2.302599   val_acc=0.165000\n",
      "iteration 0 / 1500: loss 2.302599   val_acc=0.165000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008480842911877395 reg: 0.0063965517241379305\n",
      "iteration 0 / 1500: loss 2.302614   val_acc=0.060000\n",
      "iteration 0 / 1500: loss 2.302614   val_acc=0.060000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008480842911877395 reg: 0.006431034482758621\n",
      "iteration 0 / 1500: loss 2.302571   val_acc=0.089000\n",
      "iteration 0 / 1500: loss 2.302571   val_acc=0.089000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008480842911877395 reg: 0.00646551724137931\n",
      "iteration 0 / 1500: loss 2.302590   val_acc=0.093000\n",
      "iteration 0 / 1500: loss 2.302590   val_acc=0.093000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008480842911877395 reg: 0.0065\n",
      "iteration 0 / 1500: loss 2.302589   val_acc=0.067000\n",
      "iteration 0 / 1500: loss 2.302589   val_acc=0.067000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008480842911877395 reg: 0.00653448275862069\n",
      "iteration 0 / 1500: loss 2.302600   val_acc=0.146000\n",
      "iteration 0 / 1500: loss 2.302600   val_acc=0.146000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008480842911877395 reg: 0.0065689655172413795\n",
      "iteration 0 / 1500: loss 2.302605   val_acc=0.120000\n",
      "iteration 0 / 1500: loss 2.302605   val_acc=0.120000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008591954022988506 reg: 0.005568965517241379\n",
      "iteration 0 / 1500: loss 2.302580   val_acc=0.113000\n",
      "iteration 0 / 1500: loss 2.302580   val_acc=0.113000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008591954022988506 reg: 0.005603448275862068\n",
      "iteration 0 / 1500: loss 2.302611   val_acc=0.165000\n",
      "iteration 0 / 1500: loss 2.302611   val_acc=0.165000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008591954022988506 reg: 0.005637931034482758\n",
      "iteration 0 / 1500: loss 2.302539   val_acc=0.098000\n",
      "iteration 0 / 1500: loss 2.302539   val_acc=0.098000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008591954022988506 reg: 0.005672413793103448\n",
      "iteration 0 / 1500: loss 2.302594   val_acc=0.079000\n",
      "iteration 0 / 1500: loss 2.302594   val_acc=0.079000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008591954022988506 reg: 0.005706896551724137\n",
      "iteration 0 / 1500: loss 2.302580   val_acc=0.078000\n",
      "iteration 0 / 1500: loss 2.302580   val_acc=0.078000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008591954022988506 reg: 0.005741379310344827\n",
      "iteration 0 / 1500: loss 2.302580   val_acc=0.065000\n",
      "iteration 0 / 1500: loss 2.302580   val_acc=0.065000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008591954022988506 reg: 0.005775862068965517\n",
      "iteration 0 / 1500: loss 2.302607   val_acc=0.054000\n",
      "iteration 0 / 1500: loss 2.302607   val_acc=0.054000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008591954022988506 reg: 0.0058103448275862064\n",
      "iteration 0 / 1500: loss 2.302605   val_acc=0.070000\n",
      "iteration 0 / 1500: loss 2.302605   val_acc=0.070000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008591954022988506 reg: 0.005844827586206896\n",
      "iteration 0 / 1500: loss 2.302586   val_acc=0.170000\n",
      "iteration 0 / 1500: loss 2.302586   val_acc=0.170000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008591954022988506 reg: 0.005879310344827585\n",
      "iteration 0 / 1500: loss 2.302602   val_acc=0.132000\n",
      "iteration 0 / 1500: loss 2.302602   val_acc=0.132000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008591954022988506 reg: 0.005913793103448276\n",
      "iteration 0 / 1500: loss 2.302578   val_acc=0.067000\n",
      "iteration 0 / 1500: loss 2.302578   val_acc=0.067000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008591954022988506 reg: 0.005948275862068965\n",
      "iteration 0 / 1500: loss 2.302589   val_acc=0.100000\n",
      "iteration 0 / 1500: loss 2.302589   val_acc=0.100000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008591954022988506 reg: 0.0059827586206896545\n",
      "iteration 0 / 1500: loss 2.302640   val_acc=0.156000\n",
      "iteration 0 / 1500: loss 2.302640   val_acc=0.156000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008591954022988506 reg: 0.006017241379310345\n",
      "iteration 0 / 1500: loss 2.302600   val_acc=0.132000\n",
      "iteration 0 / 1500: loss 2.302600   val_acc=0.132000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008591954022988506 reg: 0.006051724137931034\n",
      "iteration 0 / 1500: loss 2.302604   val_acc=0.154000\n",
      "iteration 0 / 1500: loss 2.302604   val_acc=0.154000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008591954022988506 reg: 0.006086206896551724\n",
      "iteration 0 / 1500: loss 2.302577   val_acc=0.164000\n",
      "iteration 0 / 1500: loss 2.302577   val_acc=0.164000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008591954022988506 reg: 0.006120689655172413\n",
      "iteration 0 / 1500: loss 2.302598   val_acc=0.062000\n",
      "iteration 0 / 1500: loss 2.302598   val_acc=0.062000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008591954022988506 reg: 0.0061551724137931035\n",
      "iteration 0 / 1500: loss 2.302631   val_acc=0.158000\n",
      "iteration 0 / 1500: loss 2.302631   val_acc=0.158000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008591954022988506 reg: 0.006189655172413793\n",
      "iteration 0 / 1500: loss 2.302602   val_acc=0.070000\n",
      "iteration 0 / 1500: loss 2.302602   val_acc=0.070000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008591954022988506 reg: 0.006224137931034482\n",
      "iteration 0 / 1500: loss 2.302596   val_acc=0.085000\n",
      "iteration 0 / 1500: loss 2.302596   val_acc=0.085000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008591954022988506 reg: 0.006258620689655173\n",
      "iteration 0 / 1500: loss 2.302618   val_acc=0.130000\n",
      "iteration 0 / 1500: loss 2.302618   val_acc=0.130000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008591954022988506 reg: 0.006293103448275862\n",
      "iteration 0 / 1500: loss 2.302572   val_acc=0.167000\n",
      "iteration 0 / 1500: loss 2.302572   val_acc=0.167000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008591954022988506 reg: 0.006327586206896552\n",
      "iteration 0 / 1500: loss 2.302574   val_acc=0.141000\n",
      "iteration 0 / 1500: loss 2.302574   val_acc=0.141000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008591954022988506 reg: 0.006362068965517241\n",
      "iteration 0 / 1500: loss 2.302616   val_acc=0.107000\n",
      "iteration 0 / 1500: loss 2.302616   val_acc=0.107000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lr: 0.008591954022988506 reg: 0.0063965517241379305\n",
      "iteration 0 / 1500: loss 2.302577   val_acc=0.106000\n",
      "iteration 0 / 1500: loss 2.302577   val_acc=0.106000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008591954022988506 reg: 0.006431034482758621\n",
      "iteration 0 / 1500: loss 2.302629   val_acc=0.138000\n",
      "iteration 0 / 1500: loss 2.302629   val_acc=0.138000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008591954022988506 reg: 0.00646551724137931\n",
      "iteration 0 / 1500: loss 2.302613   val_acc=0.116000\n",
      "iteration 0 / 1500: loss 2.302613   val_acc=0.116000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008591954022988506 reg: 0.0065\n",
      "iteration 0 / 1500: loss 2.302602   val_acc=0.099000\n",
      "iteration 0 / 1500: loss 2.302602   val_acc=0.099000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008591954022988506 reg: 0.00653448275862069\n",
      "iteration 0 / 1500: loss 2.302614   val_acc=0.043000\n",
      "iteration 0 / 1500: loss 2.302614   val_acc=0.043000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008591954022988506 reg: 0.0065689655172413795\n",
      "iteration 0 / 1500: loss 2.302619   val_acc=0.095000\n",
      "iteration 0 / 1500: loss 2.302619   val_acc=0.095000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008703065134099618 reg: 0.005568965517241379\n",
      "iteration 0 / 1500: loss 2.302615   val_acc=0.159000\n",
      "iteration 0 / 1500: loss 2.302615   val_acc=0.159000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008703065134099618 reg: 0.005603448275862068\n",
      "iteration 0 / 1500: loss 2.302604   val_acc=0.120000\n",
      "iteration 0 / 1500: loss 2.302604   val_acc=0.120000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008703065134099618 reg: 0.005637931034482758\n",
      "iteration 0 / 1500: loss 2.302596   val_acc=0.106000\n",
      "iteration 0 / 1500: loss 2.302596   val_acc=0.106000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008703065134099618 reg: 0.005672413793103448\n",
      "iteration 0 / 1500: loss 2.302603   val_acc=0.159000\n",
      "iteration 0 / 1500: loss 2.302603   val_acc=0.159000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008703065134099618 reg: 0.005706896551724137\n",
      "iteration 0 / 1500: loss 2.302623   val_acc=0.112000\n",
      "iteration 0 / 1500: loss 2.302623   val_acc=0.112000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008703065134099618 reg: 0.005741379310344827\n",
      "iteration 0 / 1500: loss 2.302589   val_acc=0.076000\n",
      "iteration 0 / 1500: loss 2.302589   val_acc=0.076000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008703065134099618 reg: 0.005775862068965517\n",
      "iteration 0 / 1500: loss 2.302598   val_acc=0.069000\n",
      "iteration 0 / 1500: loss 2.302598   val_acc=0.069000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008703065134099618 reg: 0.0058103448275862064\n",
      "iteration 0 / 1500: loss 2.302576   val_acc=0.137000\n",
      "iteration 0 / 1500: loss 2.302576   val_acc=0.137000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008703065134099618 reg: 0.005844827586206896\n",
      "iteration 0 / 1500: loss 2.302604   val_acc=0.081000\n",
      "iteration 0 / 1500: loss 2.302604   val_acc=0.081000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008703065134099618 reg: 0.005879310344827585\n",
      "iteration 0 / 1500: loss 2.302573   val_acc=0.109000\n",
      "iteration 0 / 1500: loss 2.302573   val_acc=0.109000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008703065134099618 reg: 0.005913793103448276\n",
      "iteration 0 / 1500: loss 2.302575   val_acc=0.118000\n",
      "iteration 0 / 1500: loss 2.302575   val_acc=0.118000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008703065134099618 reg: 0.005948275862068965\n",
      "iteration 0 / 1500: loss 2.302579   val_acc=0.164000\n",
      "iteration 0 / 1500: loss 2.302579   val_acc=0.164000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008703065134099618 reg: 0.0059827586206896545\n",
      "iteration 0 / 1500: loss 2.302572   val_acc=0.140000\n",
      "iteration 0 / 1500: loss 2.302572   val_acc=0.140000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008703065134099618 reg: 0.006017241379310345\n",
      "iteration 0 / 1500: loss 2.302586   val_acc=0.084000\n",
      "iteration 0 / 1500: loss 2.302586   val_acc=0.084000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008703065134099618 reg: 0.006051724137931034\n",
      "iteration 0 / 1500: loss 2.302585   val_acc=0.089000\n",
      "iteration 0 / 1500: loss 2.302585   val_acc=0.089000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008703065134099618 reg: 0.006086206896551724\n",
      "iteration 0 / 1500: loss 2.302580   val_acc=0.105000\n",
      "iteration 0 / 1500: loss 2.302580   val_acc=0.105000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008703065134099618 reg: 0.006120689655172413\n",
      "iteration 0 / 1500: loss 2.302616   val_acc=0.149000\n",
      "iteration 0 / 1500: loss 2.302616   val_acc=0.149000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008703065134099618 reg: 0.0061551724137931035\n",
      "iteration 0 / 1500: loss 2.302617   val_acc=0.142000\n",
      "iteration 0 / 1500: loss 2.302617   val_acc=0.142000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008703065134099618 reg: 0.006189655172413793\n",
      "iteration 0 / 1500: loss 2.302596   val_acc=0.123000\n",
      "iteration 0 / 1500: loss 2.302596   val_acc=0.123000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008703065134099618 reg: 0.006224137931034482\n",
      "iteration 0 / 1500: loss 2.302603   val_acc=0.095000\n",
      "iteration 0 / 1500: loss 2.302603   val_acc=0.095000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008703065134099618 reg: 0.006258620689655173\n",
      "iteration 0 / 1500: loss 2.302549   val_acc=0.069000\n",
      "iteration 0 / 1500: loss 2.302549   val_acc=0.069000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008703065134099618 reg: 0.006293103448275862\n",
      "iteration 0 / 1500: loss 2.302592   val_acc=0.125000\n",
      "iteration 0 / 1500: loss 2.302592   val_acc=0.125000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008703065134099618 reg: 0.006327586206896552\n",
      "iteration 0 / 1500: loss 2.302573   val_acc=0.079000\n",
      "iteration 0 / 1500: loss 2.302573   val_acc=0.079000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008703065134099618 reg: 0.006362068965517241\n",
      "iteration 0 / 1500: loss 2.302612   val_acc=0.120000\n",
      "iteration 0 / 1500: loss 2.302612   val_acc=0.120000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008703065134099618 reg: 0.0063965517241379305\n",
      "iteration 0 / 1500: loss 2.302593   val_acc=0.121000\n",
      "iteration 0 / 1500: loss 2.302593   val_acc=0.121000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008703065134099618 reg: 0.006431034482758621\n",
      "iteration 0 / 1500: loss 2.302585   val_acc=0.124000\n",
      "iteration 0 / 1500: loss 2.302585   val_acc=0.124000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008703065134099618 reg: 0.00646551724137931\n",
      "iteration 0 / 1500: loss 2.302598   val_acc=0.075000\n",
      "iteration 0 / 1500: loss 2.302598   val_acc=0.075000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008703065134099618 reg: 0.0065\n",
      "iteration 0 / 1500: loss 2.302601   val_acc=0.123000\n",
      "iteration 0 / 1500: loss 2.302601   val_acc=0.123000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008703065134099618 reg: 0.00653448275862069\n",
      "iteration 0 / 1500: loss 2.302593   val_acc=0.126000\n",
      "iteration 0 / 1500: loss 2.302593   val_acc=0.126000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008703065134099618 reg: 0.0065689655172413795\n",
      "iteration 0 / 1500: loss 2.302615   val_acc=0.083000\n",
      "iteration 0 / 1500: loss 2.302615   val_acc=0.083000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008814176245210728 reg: 0.005568965517241379\n",
      "iteration 0 / 1500: loss 2.302577   val_acc=0.136000\n",
      "iteration 0 / 1500: loss 2.302577   val_acc=0.136000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008814176245210728 reg: 0.005603448275862068\n",
      "iteration 0 / 1500: loss 2.302596   val_acc=0.133000\n",
      "iteration 0 / 1500: loss 2.302596   val_acc=0.133000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008814176245210728 reg: 0.005637931034482758\n",
      "iteration 0 / 1500: loss 2.302596   val_acc=0.145000\n",
      "iteration 0 / 1500: loss 2.302596   val_acc=0.145000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008814176245210728 reg: 0.005672413793103448\n",
      "iteration 0 / 1500: loss 2.302597   val_acc=0.119000\n",
      "iteration 0 / 1500: loss 2.302597   val_acc=0.119000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008814176245210728 reg: 0.005706896551724137\n",
      "iteration 0 / 1500: loss 2.302586   val_acc=0.097000\n",
      "iteration 0 / 1500: loss 2.302586   val_acc=0.097000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008814176245210728 reg: 0.005741379310344827\n",
      "iteration 0 / 1500: loss 2.302582   val_acc=0.053000\n",
      "iteration 0 / 1500: loss 2.302582   val_acc=0.053000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008814176245210728 reg: 0.005775862068965517\n",
      "iteration 0 / 1500: loss 2.302596   val_acc=0.152000\n",
      "iteration 0 / 1500: loss 2.302596   val_acc=0.152000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008814176245210728 reg: 0.0058103448275862064\n",
      "iteration 0 / 1500: loss 2.302598   val_acc=0.113000\n",
      "iteration 0 / 1500: loss 2.302598   val_acc=0.113000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008814176245210728 reg: 0.005844827586206896\n",
      "iteration 0 / 1500: loss 2.302580   val_acc=0.080000\n",
      "iteration 0 / 1500: loss 2.302580   val_acc=0.080000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008814176245210728 reg: 0.005879310344827585\n",
      "iteration 0 / 1500: loss 2.302594   val_acc=0.094000\n",
      "iteration 0 / 1500: loss 2.302594   val_acc=0.094000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008814176245210728 reg: 0.005913793103448276\n",
      "iteration 0 / 1500: loss 2.302579   val_acc=0.118000\n",
      "iteration 0 / 1500: loss 2.302579   val_acc=0.118000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008814176245210728 reg: 0.005948275862068965\n",
      "iteration 0 / 1500: loss 2.302597   val_acc=0.129000\n",
      "iteration 0 / 1500: loss 2.302597   val_acc=0.129000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008814176245210728 reg: 0.0059827586206896545\n",
      "iteration 0 / 1500: loss 2.302600   val_acc=0.129000\n",
      "iteration 0 / 1500: loss 2.302600   val_acc=0.129000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008814176245210728 reg: 0.006017241379310345\n",
      "iteration 0 / 1500: loss 2.302600   val_acc=0.135000\n",
      "iteration 0 / 1500: loss 2.302600   val_acc=0.135000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008814176245210728 reg: 0.006051724137931034\n",
      "iteration 0 / 1500: loss 2.302586   val_acc=0.079000\n",
      "iteration 0 / 1500: loss 2.302586   val_acc=0.079000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008814176245210728 reg: 0.006086206896551724\n",
      "iteration 0 / 1500: loss 2.302603   val_acc=0.073000\n",
      "iteration 0 / 1500: loss 2.302603   val_acc=0.073000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008814176245210728 reg: 0.006120689655172413\n",
      "iteration 0 / 1500: loss 2.302590   val_acc=0.084000\n",
      "iteration 0 / 1500: loss 2.302590   val_acc=0.084000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008814176245210728 reg: 0.0061551724137931035\n",
      "iteration 0 / 1500: loss 2.302637   val_acc=0.140000\n",
      "iteration 0 / 1500: loss 2.302637   val_acc=0.140000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008814176245210728 reg: 0.006189655172413793\n",
      "iteration 0 / 1500: loss 2.302593   val_acc=0.124000\n",
      "iteration 0 / 1500: loss 2.302593   val_acc=0.124000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008814176245210728 reg: 0.006224137931034482\n",
      "iteration 0 / 1500: loss 2.302595   val_acc=0.110000\n",
      "iteration 0 / 1500: loss 2.302595   val_acc=0.110000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008814176245210728 reg: 0.006258620689655173\n",
      "iteration 0 / 1500: loss 2.302588   val_acc=0.102000\n",
      "iteration 0 / 1500: loss 2.302588   val_acc=0.102000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008814176245210728 reg: 0.006293103448275862\n",
      "iteration 0 / 1500: loss 2.302561   val_acc=0.102000\n",
      "iteration 0 / 1500: loss 2.302561   val_acc=0.102000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008814176245210728 reg: 0.006327586206896552\n",
      "iteration 0 / 1500: loss 2.302563   val_acc=0.123000\n",
      "iteration 0 / 1500: loss 2.302563   val_acc=0.123000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008814176245210728 reg: 0.006362068965517241\n",
      "iteration 0 / 1500: loss 2.302598   val_acc=0.067000\n",
      "iteration 0 / 1500: loss 2.302598   val_acc=0.067000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008814176245210728 reg: 0.0063965517241379305\n",
      "iteration 0 / 1500: loss 2.302588   val_acc=0.082000\n",
      "iteration 0 / 1500: loss 2.302588   val_acc=0.082000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008814176245210728 reg: 0.006431034482758621\n",
      "iteration 0 / 1500: loss 2.302585   val_acc=0.092000\n",
      "iteration 0 / 1500: loss 2.302585   val_acc=0.092000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008814176245210728 reg: 0.00646551724137931\n",
      "iteration 0 / 1500: loss 2.302624   val_acc=0.134000\n",
      "iteration 0 / 1500: loss 2.302624   val_acc=0.134000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008814176245210728 reg: 0.0065\n",
      "iteration 0 / 1500: loss 2.302610   val_acc=0.078000\n",
      "iteration 0 / 1500: loss 2.302610   val_acc=0.078000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008814176245210728 reg: 0.00653448275862069\n",
      "iteration 0 / 1500: loss 2.302599   val_acc=0.157000\n",
      "iteration 0 / 1500: loss 2.302599   val_acc=0.157000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.008814176245210728 reg: 0.0065689655172413795\n",
      "iteration 0 / 1500: loss 2.302601   val_acc=0.116000\n",
      "iteration 0 / 1500: loss 2.302601   val_acc=0.116000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.00892528735632184 reg: 0.005568965517241379\n",
      "iteration 0 / 1500: loss 2.302579   val_acc=0.084000\n",
      "iteration 0 / 1500: loss 2.302579   val_acc=0.084000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.00892528735632184 reg: 0.005603448275862068\n",
      "iteration 0 / 1500: loss 2.302637   val_acc=0.152000\n",
      "iteration 0 / 1500: loss 2.302637   val_acc=0.152000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.00892528735632184 reg: 0.005637931034482758\n",
      "iteration 0 / 1500: loss 2.302582   val_acc=0.095000\n",
      "iteration 0 / 1500: loss 2.302582   val_acc=0.095000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.00892528735632184 reg: 0.005672413793103448\n",
      "iteration 0 / 1500: loss 2.302631   val_acc=0.099000\n",
      "iteration 0 / 1500: loss 2.302631   val_acc=0.099000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.00892528735632184 reg: 0.005706896551724137\n",
      "iteration 0 / 1500: loss 2.302572   val_acc=0.151000\n",
      "iteration 0 / 1500: loss 2.302572   val_acc=0.151000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.00892528735632184 reg: 0.005741379310344827\n",
      "iteration 0 / 1500: loss 2.302588   val_acc=0.145000\n",
      "iteration 0 / 1500: loss 2.302588   val_acc=0.145000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.00892528735632184 reg: 0.005775862068965517\n",
      "iteration 0 / 1500: loss 2.302590   val_acc=0.134000\n",
      "iteration 0 / 1500: loss 2.302590   val_acc=0.134000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.00892528735632184 reg: 0.0058103448275862064\n",
      "iteration 0 / 1500: loss 2.302612   val_acc=0.065000\n",
      "iteration 0 / 1500: loss 2.302612   val_acc=0.065000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.00892528735632184 reg: 0.005844827586206896\n",
      "iteration 0 / 1500: loss 2.302612   val_acc=0.045000\n",
      "iteration 0 / 1500: loss 2.302612   val_acc=0.045000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.00892528735632184 reg: 0.005879310344827585\n",
      "iteration 0 / 1500: loss 2.302603   val_acc=0.122000\n",
      "iteration 0 / 1500: loss 2.302603   val_acc=0.122000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.00892528735632184 reg: 0.005913793103448276\n",
      "iteration 0 / 1500: loss 2.302612   val_acc=0.084000\n",
      "iteration 0 / 1500: loss 2.302612   val_acc=0.084000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.00892528735632184 reg: 0.005948275862068965\n",
      "iteration 0 / 1500: loss 2.302571   val_acc=0.092000\n",
      "iteration 0 / 1500: loss 2.302571   val_acc=0.092000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.00892528735632184 reg: 0.0059827586206896545\n",
      "iteration 0 / 1500: loss 2.302615   val_acc=0.132000\n",
      "iteration 0 / 1500: loss 2.302615   val_acc=0.132000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.00892528735632184 reg: 0.006017241379310345\n",
      "iteration 0 / 1500: loss 2.302602   val_acc=0.114000\n",
      "iteration 0 / 1500: loss 2.302602   val_acc=0.114000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.00892528735632184 reg: 0.006051724137931034\n",
      "iteration 0 / 1500: loss 2.302616   val_acc=0.163000\n",
      "iteration 0 / 1500: loss 2.302616   val_acc=0.163000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.00892528735632184 reg: 0.006086206896551724\n",
      "iteration 0 / 1500: loss 2.302583   val_acc=0.153000\n",
      "iteration 0 / 1500: loss 2.302583   val_acc=0.153000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 900 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1000 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 1400 / 1500: loss nan   val_acc=0.087000\n",
      "lr: 0.00892528735632184 reg: 0.006120689655172413\n",
      "iteration 0 / 1500: loss 2.302591   val_acc=0.120000\n",
      "iteration 0 / 1500: loss 2.302591   val_acc=0.120000\n",
      "iteration 100 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 200 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 300 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 400 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 500 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 600 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 700 / 1500: loss nan   val_acc=0.087000\n",
      "iteration 800 / 1500: loss nan   val_acc=0.087000\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-71-317806e67c5f>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     35\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     36\u001b[0m         \u001b[1;31m# Train the network\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 37\u001b[1;33m         stats = net.train(X_train, y_train, X_val, y_val,\n\u001b[0m\u001b[0;32m     38\u001b[0m                     \u001b[0mnum_iters\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m1500\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mbatch_size\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m200\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     39\u001b[0m                     \u001b[0mlearning_rate\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mlr\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlearning_rate_decay\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m0.95\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mE:\\internship\\code\\cs231n\\assignment1_jupyter\\assignment1\\cs231n\\classifiers\\neural_net.py\u001b[0m in \u001b[0;36mtrain\u001b[1;34m(self, X, y, X_val, y_val, learning_rate, learning_rate_decay, reg, num_iters, batch_size, verbose)\u001b[0m\n\u001b[0;32m    197\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    198\u001b[0m             \u001b[1;31m# Compute loss and gradients using the current minibatch\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 199\u001b[1;33m             \u001b[0mloss\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgrads\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mloss\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mX_batch\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0my_batch\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mreg\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mreg\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    200\u001b[0m             \u001b[0mloss_history\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mloss\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    201\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mE:\\internship\\code\\cs231n\\assignment1_jupyter\\assignment1\\cs231n\\classifiers\\neural_net.py\u001b[0m in \u001b[0;36mloss\u001b[1;34m(self, X, y, reg)\u001b[0m\n\u001b[0;32m    111\u001b[0m         \u001b[0mloss\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m-\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msum\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mlog\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mP\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0marange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msample_num\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    112\u001b[0m         \u001b[0mloss\u001b[0m \u001b[1;33m/=\u001b[0m \u001b[0msample_num\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 113\u001b[1;33m         \u001b[0mloss\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[0mreg\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msum\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mW1\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mW1\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mreg\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msum\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mW2\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mW2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    114\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    115\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m<__array_function__ internals>\u001b[0m in \u001b[0;36msum\u001b[1;34m(*args, **kwargs)\u001b[0m\n",
      "\u001b[1;32mD:\\env\\Anaconda3\\lib\\site-packages\\numpy\\core\\fromnumeric.py\u001b[0m in \u001b[0;36msum\u001b[1;34m(a, axis, dtype, out, keepdims, initial, where)\u001b[0m\n\u001b[0;32m   2245\u001b[0m         \u001b[1;32mreturn\u001b[0m \u001b[0mres\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2246\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 2247\u001b[1;33m     return _wrapreduction(a, np.add, 'sum', axis, dtype, out, keepdims=keepdims,\n\u001b[0m\u001b[0;32m   2248\u001b[0m                           initial=initial, where=where)\n\u001b[0;32m   2249\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mD:\\env\\Anaconda3\\lib\\site-packages\\numpy\\core\\fromnumeric.py\u001b[0m in \u001b[0;36m_wrapreduction\u001b[1;34m(obj, ufunc, method, axis, dtype, out, **kwargs)\u001b[0m\n\u001b[0;32m     85\u001b[0m                 \u001b[1;32mreturn\u001b[0m \u001b[0mreduction\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0maxis\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0maxis\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mout\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mout\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mpasskwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     86\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 87\u001b[1;33m     \u001b[1;32mreturn\u001b[0m \u001b[0mufunc\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mreduce\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mout\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mpasskwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     88\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     89\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "best_net = None # store the best model into this \n",
    "\n",
    "#################################################################################\n",
    "# TODO: Tune hyperparameters using the validation set. Store your best trained  #\n",
    "# model in best_net.                                                            #\n",
    "#                                                                               #\n",
    "# To help debug your network, it may help to use visualizations similar to the  #\n",
    "# ones we used above; these visualizations will have significant qualitative    #\n",
    "# differences from the ones we saw above for the poorly tuned network.          #\n",
    "#                                                                               #\n",
    "# Tweaking hyperparameters by hand can be fun, but you might find it useful to  #\n",
    "# write code to sweep through possible combinations of hyperparameters          #\n",
    "# automatically like we did on the previous exercises.                          #\n",
    "#################################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "lr_lim = [0.008758620689655173-0.0005,0.008758620689655173+0.0005]\n",
    "reg_lim = [0.0060689655172413794-0.0005,0.0060689655172413794+0.0005]\n",
    "\n",
    "lrs = np.linspace(lr_lim[0],lr_lim[1],10)\n",
    "regs = np.linspace(reg_lim[0],reg_lim[1],30)\n",
    "input_size = 32 * 32 * 3\n",
    "hidden_size = 50\n",
    "num_classes = 10\n",
    "\n",
    "best_acc = 0.0\n",
    "best_net = None\n",
    "\n",
    "print(regs)\n",
    "\n",
    "for lr in lrs:\n",
    "    for reg in regs:\n",
    "        print('lr:',lr,'reg:',reg)\n",
    "        net = TwoLayerNet(input_size, hidden_size, num_classes)\n",
    "\n",
    "        # Train the network\n",
    "        stats = net.train(X_train, y_train, X_val, y_val,\n",
    "                    num_iters=1500, batch_size=200,\n",
    "                    learning_rate=lr, learning_rate_decay=0.95,\n",
    "                    reg=reg, verbose=True)\n",
    "\n",
    "        # Predict on the validation set\n",
    "        val_acc = (net.predict(X_val) == y_val).mean()\n",
    "        if val_acc > best_acc:\n",
    "            best_acc = val_acc\n",
    "            best_net = net\n",
    "        \n",
    "        \n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "0.008758620689655173 0.60689655172413794"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "id": "val_accuracy"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation accuracy:  0.463\n"
     ]
    }
   ],
   "source": [
    "# Print your validation accuracy: this should be above 48%\n",
    "val_acc = (best_net.predict(X_val) == y_val).mean()\n",
    "print('Validation accuracy: ', val_acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'TwoLayerNet' object has no attribute 'reg'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-68-761b5dd37069>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mbest_net\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mreg\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: 'TwoLayerNet' object has no attribute 'reg'"
     ]
    }
   ],
   "source": [
    "print(best_net)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize the weights of the best network\n",
    "show_net_weights(best_net)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Run on the test set\n",
    "When you are done experimenting, you should evaluate your final trained network on the test set; you should get above 48%."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "id": "test_accuracy"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test accuracy:  0.434\n"
     ]
    }
   ],
   "source": [
    "# Print your test accuracy: this should be above 48%\n",
    "test_acc = (best_net.predict(X_test) == y_test).mean()\n",
    "print('Test accuracy: ', test_acc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "**Inline Question**\n",
    "\n",
    "Now that you have trained a Neural Network classifier, you may find that your testing accuracy is much lower than the training accuracy. In what ways can we decrease this gap? Select all that apply.\n",
    "\n",
    "1. Train on a larger dataset.\n",
    "2. Add more hidden units.\n",
    "3. Increase the regularization strength.\n",
    "4. None of the above.\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$\n",
    "\n",
    "$\\color{blue}{\\textit Your Explanation:}$\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
